import {defineStore} from 'pinia'
import {listStorageConfig} from '@/api/filemanager/storage'

/**
 * 文件存储配置缓存管理 (uni-app版本)
 * 用于缓存存储配置列表，避免重复请求API
 */
export const useFileConfigStore = defineStore('fileConfig', {
    state: () => ({
        // 存储配置列表
        configs: [], // 缓存时间戳
        cacheTime: null, // 缓存有效期（毫秒）- 默认1天
        cacheExpiry: 60 * 60 * 1000 * 24, // 是否正在加载
        loading: false, // 是否已初始化
        initialized: false
    }),

    getters: {
        /**
         * 获取启用的存储配置列表
         */
        enabledConfigs: (state) => {
            return state.configs.filter(config => config.status === 1)
        },

        /**
         * 获取默认存储配置
         */
        defaultConfig: (state) => {
            return state.configs.find(config => config.isDefault === 1 && config.status === 1)
        },

        /**
         * 检查缓存是否有效
         */
        isCacheValid: (state) => {
            if (!state.cacheTime) return false
            return (Date.now() - state.cacheTime) < state.cacheExpiry
        },

        /**
         * 检查是否需要刷新缓存
         */
        needsRefresh: (state) => {
            return !state.initialized || !state.isCacheValid || state.configs.length === 0
        }
    },

    actions: {
        /**
         * 获取存储配置列表（智能缓存）
         * @param {Object} options - 选项
         * @param {boolean} options.forceRefresh - 是否强制刷新缓存
         * @param {boolean} options.enabledOnly - 是否只返回启用的配置
         * @returns {Promise<Array>} 存储配置列表
         */
        async getConfigs(options = {}) {
            const {forceRefresh = false, enabledOnly = true} = options

            // 如果强制刷新，直接重新加载
            if (forceRefresh) {
                await this.loadConfigs()
                return enabledOnly ? this.enabledConfigs : this.configs
            }

            // 如果缓存有效，直接返回缓存数据
            if (!this.needsRefresh) {
                return enabledOnly ? this.enabledConfigs : this.configs
            }

            // 避免重复加载 - 如果正在加载，等待加载完成
            if (this.loading) {
                // 等待当前加载完成
                while (this.loading) {
                    await new Promise(resolve => setTimeout(resolve, 100))
                }
                return enabledOnly ? this.enabledConfigs : this.configs
            }

            // 自动加载数据
            try {
                await this.loadConfigs()
            } catch (error) {
                console.error('❌ 加载文件存储配置失败:', error)
                // 即使加载失败，也返回当前缓存的数据
            }
            return enabledOnly ? this.enabledConfigs : this.configs
        },

        /**
         * 加载存储配置列表
         */
        async loadConfigs() {
            if (this.loading) return

            this.loading = true
            try {
                const response = await listStorageConfig({
                    pageNum: 1, pageSize: 100, status: undefined // 获取所有状态的配置
                })

                if (response.code === 200) {
                    this.configs = response.rows || []
                    this.cacheTime = Date.now()
                    this.initialized = true
                } else {
                    throw new Error(response.msg || '加载文件存储配置失败')
                }
            } catch (error) {
                throw error
            } finally {
                this.loading = false
            }
        },

        /**
         * 获取指定ID的存储配置（智能缓存）
         * @param {number} configId - 配置ID
         * @returns {Promise<Object|null>} 存储配置
         */
        async getConfigById(configId) {
            if (!configId) return null

            // 自动获取配置列表（包括已停用的）
            const configs = await this.getConfigs({enabledOnly: false})
            const config = configs.find(config => config.configId === configId) || null


            return config
        },

        /**
         * 获取默认存储配置（智能缓存）
         * @returns {Promise<Object|null>} 默认存储配置
         */
        async getDefaultConfig() {
            // 自动获取启用的配置列表
            await this.getConfigs({enabledOnly: true})


            return this.defaultConfig
        },

        /**
         * 刷新缓存
         * 在存储配置发生变更时调用
         */
        async refreshCache() {
            this.clearCache()
            await this.loadConfigs()
        },

        /**
         * 预加载配置（可选的预热方法）
         * 应用启动时可以调用此方法预热缓存
         */
        async preloadConfigs() {
            if (!this.initialized) {
                await this.getConfigs()
            }
        },

        /**
         * 清空缓存
         */
        clearCache() {
            this.configs = []
            this.cacheTime = null
            this.initialized = false
        },

        /**
         * 设置缓存有效期
         * @param {number} expiry - 有效期（毫秒）
         */
        setCacheExpiry(expiry) {
            this.cacheExpiry = expiry
        },

        /**
         * 添加存储配置到缓存
         * @param {Object} config - 存储配置
         */
        addConfig(config) {
            if (config && config.configId) {
                // 检查是否已存在
                const index = this.configs.findIndex(c => c.configId === config.configId)
                if (index === -1) {
                    this.configs.push(config)
                }
            }
        },

        /**
         * 更新缓存中的存储配置
         * @param {Object} config - 更新的存储配置
         */
        updateConfig(config) {
            if (config && config.configId) {
                const index = this.configs.findIndex(c => c.configId === config.configId)
                if (index !== -1) {
                    this.configs[index] = {...this.configs[index], ...config}
                }
            }
        },

        /**
         * 从缓存中删除存储配置
         * @param {number} configId - 配置ID
         */
        removeConfig(configId) {
            if (configId) {
                const index = this.configs.findIndex(c => c.configId === configId)
                if (index !== -1) {
                    this.configs.splice(index, 1)
                }
            }
        }
    }
})

/**
 * 便捷函数：获取文件存储配置列表
 * @param {Object} options - 选项
 * @returns {Promise<Array>} 存储配置列表
 */
export async function getFileConfigs(options = {}) {
    const store = useFileConfigStore()
    return await store.getConfigs(options)
}

/**
 * 便捷函数：获取默认文件存储配置
 * @returns {Promise<Object|null>} 默认存储配置
 */
export async function getDefaultFileConfig() {
    const store = useFileConfigStore()
    return await store.getDefaultConfig()
}

/**
 * 便捷函数：根据ID获取文件存储配置
 * @param {number} configId - 配置ID
 * @returns {Promise<Object|null>} 存储配置
 */
export async function getFileConfigById(configId) {
    const store = useFileConfigStore()
    return await store.getConfigById(configId)
}

/**
 * 便捷函数：刷新文件存储配置缓存
 */
export async function refreshFileConfigCache() {
    const store = useFileConfigStore()
    return await store.refreshCache()
}

/**
 * 便捷函数：获取默认配置ID或第一个可用配置ID
 * @param {Array} configs - 配置列表（可选，如果不传会自动获取）
 * @returns {Promise<number|null>} 配置ID
 */
export async function getDefaultConfigId(configs = null) {
    if (!configs) {
        const store = useFileConfigStore()
        configs = await store.getConfigs({enabledOnly: true})
    }

    if (!configs || configs.length === 0) {
        return null
    }

    // 优先使用默认配置
    const defaultConfig = configs.find(config => config.isDefault === 1)
    if (defaultConfig) {
        return defaultConfig.configId
    }

    // 如果没有默认配置，使用第一个可用配置
    const firstConfig = configs[0]
    return firstConfig.configId
}
